package demo2;

import java.util.concurrent.Callable;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: mac
 * Date: 2022-09-06
 * Time: 16:28
 */
abstract class Shape {
    public int a;
    public void func() {
        System.out.println("测试普通方法");
    }
    public abstract void draw();//抽象方法
}

abstract class A extends Shape{
    public abstract void funcA();
}
class B extends A {
    @Override
    public void funcA(){

    }
    @Override
    public void draw(){

    }
}
class Rect extends Shape {
    @Override
    public void draw() {
        System.out.println("♦");
    }
}

class Flower extends Shape {
    @Override
    public void draw(){
        System.out.println("❀");
    }
}

class Triangle extends Shape {
    @Override
    public void draw(){
        System.out.println("△");
    }
}

class Clyle extends Shape {
    @Override
    public void draw(){
        System.out.println("●");
    }
}

public class Test {

    public static void drawMap(Shape shape) {
        shape.draw();
    }

    public static void main(String[] args) {
        //Shape shape = new Shape();

        //抽象类
        //1.包含抽象方法的类，叫抽象类
        //2.什么是抽象方法，一个没有具体实现的方法被abstract修饰
        //3.抽象类是不可以被实例化的 - no new
        //4.因为不能被实例化，所以，这个抽象类，其实只能被继承
        //5.抽象类当中，也可以包含，和普通类一样的成员方法
        //6.一个普通类，继承了一个抽象类，那么这个普通类当中，需要重写这个抽象类中所有的抽象方法
        //7.抽象类最大的作用就是被继承
        //8.一个抽象类A如果继承了另一个抽象类B，那么A可以不实现抽象父类B的继承方法
        //9.结合第8点，当A类再次被一个普通类继承后，那么A和B两个抽象类当中的抽象方法，必须被重写
        //10.抽象类不能被final所修饰，抽象方法也不可以被final修饰
        Shape shape = new Rect();
        drawMap(shape);
        Clyle cycle = new Clyle();
        drawMap(cycle);
    }
}
